package com.mxwl.cbg.common.Extract;

import lombok.extern.slf4j.Slf4j;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Slf4j
public class EquipmentDataExtract extends BaseExtract{


    // 修改后的正则表达式，现在可以匹配整数或浮点数作为属性值

    private static final Pattern specialEquipmentPattern = Pattern.compile("玩家\\d+专用");
    private static final Pattern attributePattern = Pattern.compile("\\b(\\p{IsHan}+?)\\s*([+-]\\s*[\\d.]+)\\b");
    private static final Pattern makerPattern = Pattern.compile("制造者[：:]\\s*(.+)");
    private static final Pattern enhanceLevelPattern = Pattern.compile("锻炼等级[\\s:：]*?(\\d+)");
    private static final Pattern gemstonePattern = Pattern.compile("镶嵌宝石\\s*[：:]?\\s*([^\\n]+)");
    private static final Pattern durabilityPattern = Pattern.compile("耐久度\\s(\\d+)");
    private static final Pattern elementPattern = Pattern.compile("五行\\s+(\\p{IsHan})");
    private static final Pattern repairFailurePattern = Pattern.compile("修理失败\\s*(\\d+)\\s*次");
    private static final Pattern specialSkillPattern = Pattern.compile("特技[：:]\\s*([^\\n]+)");
    private static final Pattern runeCombinationPattern = Pattern.compile("符石组合[：:]\\s*([^\\n]+)");
    private static final Pattern partConditionPattern = Pattern.compile("部位条件[：:]\\s*([^\\n]+)");
    private static final Pattern sectConditionPattern = Pattern.compile("门派条件[：:]\\s*([^\\n]+)");
    private static final Pattern effectsPattern = Pattern.compile("特效[：:]\\s*([^\\n]+)");
    private static final Pattern refiningEffectPattern = Pattern.compile(
            // 匹配格式: [+-]数字或小数 中文属性名
            "([+-]\\s*[\\d.]+)\\s*(\\p{IsHan}+)"
    );
    private static final Pattern specialEffectsPattern = Pattern.compile(
            // 匹配不包含常见关键词的行，但包含特殊效果关键词
            "^(?!.*?(?:门派条件|部位条件|制造者|熔炼效果|符石组合|耐久度|锻炼等级|开运孔数|镶嵌宝石|等级|五行|特技|特效|套装效果))" +
                    "([^\\n]{10,}?(?:提升|增加|几率|临时|效果|造成|降低|触发|法术|攻击)[^\\n]{10,})"
    );
    private static final Pattern starAttributePattern = Pattern.compile("星位[：:]\\s*(\\p{IsHan}+)\\s*([+-]\\s*[\\d.]+)");
    private static final Pattern xxhhPattern = Pattern.compile("星相互合[：:]\\s*(\\p{IsHan}+)\\s*[+＋]\\s*([\\d.]+)");
    private static final Pattern holeInfoPattern = Pattern.compile(
            "开运孔数[：:](\\d+)孔/(\\d+)孔" +  // 匹配基本格式
                    "(?:\\s*\\(双(\\d+)孔\\))?"      // 匹配可选的双孔位信息
    );
    private static final Pattern setEffectPattern = Pattern.compile("套装效果[：:]\\s*([^\\n]+)");



    /// 提取属性
    ///
    /// @param equipmentText 处理文本
    /// @return
    public static Map<String, Double> extractAttributes(String equipmentText) {
        Map<String, Double> attributesMap = new HashMap<>();

        // 按行处理文本
        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            // 跳过符石行和星相互合行
            if (line.contains("符石") || line.contains("星相互合") || line.contains("星位")) {
                continue;
            }
            Matcher matcher = attributePattern.matcher(line);
            while (matcher.find()) {
                String attributeName = matcher.group(1);
                String attributeValue = matcher.group(2);
                // 将属性值作为Double类型存储
                if (attributesMap.containsKey(attributeName)) {
                    log.warn("属性已存在，已覆盖，【{}】属性,数据:\r{}", attributeName, equipmentText);
                }
                attributesMap.put(attributeName, Double.valueOf(attributeValue));
            }
        }
        return attributesMap;
    }


    /**
     * 提取制造者
     *
     * @param equipmentText
     * @return
     */
    public static String extractMaker(String equipmentText) {
        // 正则表达式匹配制造者信息

        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            if (line.contains("制造者")) {
                Matcher matcher = makerPattern.matcher(line);
                if (matcher.find()) {
                    // 返回制造者信息（去除前后空格）
                    return matcher.group(1).trim();
                }
                // 如果正则不匹配，尝试简单分割
                if (line.contains("：")) {
                    return line.split("：")[1].trim();
                } else if (line.contains(":")) {
                    return line.split(":")[1].trim();
                }
            }
        }

        return null; // 如果没有找到制造者信息
    }

    /**
     * 提取锻炼等级
     *
     * @param equipmentText
     * @return
     */
    public static int extractEnhanceLevel(String equipmentText) {
        // 正则表达式匹配锻炼等级

        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            if (line.contains("锻炼等级")) {
                Matcher matcher = enhanceLevelPattern.matcher(line);
                if (matcher.find()) {
                    // 提取数字部分并转为整数
                    return Integer.parseInt(matcher.group(1));
                }
            }
        }

        return 0; // 默认值，表示未找到锻炼等级
    }

    /**
     * 提取镶嵌宝石
     *
     * @param equipmentText
     * @return
     */
    public static List<String> extractGemstones(String equipmentText) {
        List<String> gemstones = new ArrayList<>();

        // 正则表达式匹配宝石信息

        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            if (line.contains("镶嵌宝石")) {
                Matcher matcher = gemstonePattern.matcher(line);
                if (matcher.find()) {
                    // 提取宝石部分（如"太阳石、 红玛瑙"）
                    String gemsPart = matcher.group(1).trim();

                    // 分割多个宝石名称（支持顿号、逗号、空格分隔）
                    String[] gems = gemsPart.split("[、,，\\s]+");

                    // 收集非空宝石名称
                    for (String gem : gems) {
                        if (!gem.trim().isEmpty()) {
                            gemstones.add(gem.trim());
                        }
                    }
                    break; // 找到后退出循环
                }
            }
        }

        return gemstones;
    }

    /**
     * 提取耐久度
     *
     * @param equipmentText
     * @return
     */
    public static int extractDurability(String equipmentText) {
        // 正则表达式精确匹配"耐久度 数字"格式

        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            // 使用精确匹配而不是contains
            if (line.startsWith("耐久度 ")) {
                Matcher matcher = durabilityPattern.matcher(line);
                if (matcher.find()) {
                    // 提取数字部分并转为整数
                    return Integer.parseInt(matcher.group(1));
                }
            }
        }

        return -1; // 默认值，表示未找到耐久度信息
    }

    /**
     * 提取五行
     *
     * @param equipmentText
     * @return
     */
    public static String extractElement(String equipmentText) {
        // 正则表达式匹配五行属性

        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            if (line.contains("五行")) {
                Matcher matcher = elementPattern.matcher(line);
                if (matcher.find()) {
                    // 返回五行属性（金、木、水、火、土）
                    return matcher.group(1);
                }
            }
        }

        return "无"; // 默认值，表示没有五行属性
    }

    // 1. 提取修理失败次数
    public static int extractRepairFailTimes(String equipmentText) {
        Matcher matcher = repairFailurePattern.matcher(equipmentText);
        if (matcher.find()) {
            return Integer.parseInt(matcher.group(1));
        }
        return 0; // 默认没有修理失败
    }

    // 2. 提取特技
    public static String extractSpecialSkill(String equipmentText) {
        Matcher matcher = specialSkillPattern.matcher(equipmentText);
        if (matcher.find()) {
            return matcher.group(1).trim();
        }
        return ""; // 默认没有特技
    }

    // 3. 提取符石组合
    public static String extractRuneCombination(String equipmentText) {
        Matcher matcher = runeCombinationPattern.matcher(equipmentText);
        if (matcher.find()) {
            return matcher.group(1).trim();
        }
        return ""; // 默认没有符石组合
    }

    // 4. 提取部位条件（可能多个）
    public static List<String> extractPartConditions(String equipmentText) {
        List<String> parts = new ArrayList<>();
        Matcher matcher = partConditionPattern.matcher(equipmentText);

        if (matcher.find()) {
            // 分割多个部位条件（支持斜杠、顿号、逗号、空格分隔）
            String[] conditions = matcher.group(1).split("[/、，,\\s]+");
            for (String condition : conditions) {
                if (!condition.trim().isEmpty()) {
                    parts.add(condition.trim());
                }
            }
        }

        return parts;
    }

    /**
     * 判断是否是专用装备
     *
     * @param text
     * @return
     */
    public static boolean extractSpecialEquipment(String text) {
        Matcher matcher = specialEquipmentPattern.matcher(text);
        return matcher.find();
    }

    // 5. 提取门派条件
    public static String extractSectCondition(String equipmentText) {
        Matcher matcher = sectConditionPattern.matcher(equipmentText);
        if (matcher.find()) {
            return matcher.group(1).trim();
        }
        return ""; // 默认没有门派条件
    }

    // 6. 提取特效（可能多个）
    public static List<String> extractEffects(String equipmentText) {
        List<String> effects = new ArrayList<>();
        Matcher matcher = effectsPattern.matcher(equipmentText);

        if (matcher.find()) {
            // 分割多个特效（支持空格、顿号、逗号分隔）
            String[] effectArray = matcher.group(1).split("[\\s、，,]+");
            for (String effect : effectArray) {
                if (!effect.trim().isEmpty()) {
                    effects.add(effect.trim());
                }
            }
        }

        return effects;
    }


    /**
     * 提取熔炼效果附带的属性
     *
     * @param equipmentText
     * @return
     */
    public static Map<String, Double> extractRefiningEffects(String equipmentText) {
        Map<String, Double> refiningEffects = new HashMap<>();

        // 1. 定位熔炼效果部分
        int refiningIndex = equipmentText.indexOf("熔炼效果");
        if (refiningIndex == -1) {
            return refiningEffects; // 没有熔炼效果
        }

        // 2. 提取熔炼效果部分（从"熔炼效果"开始到文本结束）
        String refiningSection = equipmentText.substring(refiningIndex);

        // 3. 正则表达式匹配"值 属性名"格式，现在支持整数和小数

        // 4. 匹配所有属性
        Matcher matcher = refiningEffectPattern.matcher(refiningSection);
        while (matcher.find()) {
            // 提取数值部分（去除空格）
            String valueStr = matcher.group(1).replaceAll("\\s", "");
            double attributeValue = Double.parseDouble(valueStr);

            // 提取属性名
            String attributeName = matcher.group(2);

            // 累加相同属性的值
            refiningEffects.merge(attributeName, attributeValue, Double::sum);
        }

        return refiningEffects;
    }

    /**
     * 提取附带buff效果
     *
     * @param equipmentText
     * @return
     */
    public static String extractSpecialEffectsEnhanced(String equipmentText) {
        // 1. 定位符石组合之后的部分
        int runeCombinationIndex = equipmentText.indexOf("符石组合");
        if (runeCombinationIndex == -1) {
            return ""; // 没有符石组合，可能没有特殊效果
        }

        // 2. 提取符石组合之后到制造者/熔炼效果之前的内容
        String effectSection = equipmentText.substring(runeCombinationIndex);

        // 3. 正则表达式匹配特殊效果描述行

        // 4. 按行扫描
        String[] lines = effectSection.split("\\r?\\n");
        for (String line : lines) {
            line = line.trim();
            if (line.isEmpty()) continue;

            Matcher matcher = specialEffectsPattern.matcher(line);
            if (matcher.find()) {
                return line;
            }

            // 备选匹配：包含数字和效果关键词的行
            if (line.matches(".*[0-9%.].*") &&
                    (line.contains("提升") || line.contains("增加") || line.contains("几率"))) {
                return line;
            }
        }

        return ""; // 没有找到特殊效果
    }


    /**
     * 提取星位加成属性
     *
     * @param equipmentText
     * @return
     */
    public static Map<String, Double> extractStarAttribute(String equipmentText) {
        Map<String, Double> starAttribute = new HashMap<>();
        // 正则表达式匹配星位属性，现在支持整数和小数
        // 按行扫描文本
        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            if (line.contains("星位")) {
                Matcher matcher = starAttributePattern.matcher(line);
                if (matcher.find()) {
                    // 提取属性名和数值
                    String attributeName = matcher.group(1);
                    double attributeValue = Double.parseDouble(matcher.group(2));
                    // 存入Map
                    starAttribute.put(attributeName, attributeValue);
                    return starAttribute; // 找到后立即返回
                }
            }
        }
        return starAttribute; // 没有找到星位属性时返回空Map
    }

    /**
     * 提取星相互合加成属性
     *
     * @param equipmentText
     * @return
     */
    public static Map<String, Double> extractXxhhAttribute(String equipmentText) {
        Map<String, Double> starAttribute = new HashMap<>();
        // 正则表达式匹配星位属性，现在支持整数和小数
        // 按行扫描文本
        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            if (line.contains("星相互合")) {
                Matcher matcher = xxhhPattern.matcher(line);
                if (matcher.find()) {
                    // 提取属性名和数值
                    String attributeName = matcher.group(1);
                    double attributeValue = Double.parseDouble(matcher.group(2));
                    // 存入Map
                    starAttribute.put(attributeName, attributeValue);
                    return starAttribute; // 找到后立即返回
                }
            }
        }
        return starAttribute; // 没有找到属性时返回空Map
    }

    /**
     * 提取判断装备是否已幻化
     *
     * @param equipmentText
     * @return
     */
    public static boolean extractTurned(String equipmentText) {

        // 按行扫描文本
        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            if (line.contains("【已幻化】")) {
                return true;
            }
        }
        return false;
    }

    /**
     * 提取开孔信息（返回Map形式）
     */
    public static Map<String, Integer> extractHolesInfo(String equipmentText) {
        Map<String, Integer> holesInfo = new HashMap<>();
        holesInfo.put("opened", 0);
        holesInfo.put("total", 0);
        holesInfo.put("doubleHoles", 0);

        // 正则表达式匹配开孔信息

        // 按行搜索
        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            if (line.contains("开运孔数")) {
                Matcher matcher = holeInfoPattern.matcher(line);
                if (matcher.find()) {
                    // 提取已开孔数
                    holesInfo.put("opened", Integer.parseInt(matcher.group(1)));

                    // 提取总可开孔数
                    holesInfo.put("total", Integer.parseInt(matcher.group(2)));

                    // 提取双孔位值（如果有）
                    if (matcher.group(3) != null) {
                        holesInfo.put("doubleHoles", Integer.parseInt(matcher.group(3)));
                    }
                    return holesInfo;
                }
            }
        }

        return holesInfo;
    }


    /**
     * 提取套装效果
     */
    public static String extractSetEffect(String equipmentText) {
        // 正则表达式匹配套装效果

        // 按行搜索
        String[] lines = equipmentText.split("\\r?\\n");
        for (String line : lines) {
            if (line.contains("套装效果")) {
                Matcher matcher = setEffectPattern.matcher(line);
                if (matcher.find()) {
                    // 提取套装效果描述
                    return matcher.group(1).trim();
                }

                // 如果正则不匹配，尝试简单提取
                if (line.contains("：")) {
                    return line.split("：")[1].trim();
                } else if (line.contains(":")) {
                    return line.split(":")[1].trim();
                }
            }
        }

        return ""; // 没有套装效果
    }


}
